package org.gap.dao;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.gap.domain.Guichets;

import org.skyway.spring.util.dao.AbstractJpaDao;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

/**
 * DAO to manage Guichets entities.
 * 
 */
@Repository("GuichetsDAO")
@Transactional
public class GuichetsDAOImpl extends AbstractJpaDao<Guichets> implements
		GuichetsDAO {

	/**
	 * Set of entity classes managed by this DAO.  Typically a DAO manages a single entity.
	 *
	 */
	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(Arrays.asList(new Class<?>[] { Guichets.class }));

	/**
	 * EntityManager injected by Spring for persistence unit 
	 *
	 */
	@PersistenceContext(unitName = "")
	private EntityManager entityManager;

	/**
	 * Instantiates a new GuichetsDAOImpl
	 *
	 */
	public GuichetsDAOImpl() {
		super();
	}

	/**
	 * Get the entity manager that manages persistence unit 
	 *
	 */
	public EntityManager getEntityManager() {
		return entityManager;
	}

	/**
	 * Returns the set of entity classes managed by this DAO.
	 *
	 */
	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	/**
	 * JPQL Query - findGuichetsByGuiPaysContaining
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiPaysContaining(String guiPays) throws DataAccessException {

		return findGuichetsByGuiPaysContaining(guiPays, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiPaysContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiPaysContaining(String guiPays, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiPaysContaining", startResult, maxRows, guiPays);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiCodeNouvEtablissement
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiCodeNouvEtablissement(String guiCodeNouvEtablissement) throws DataAccessException {

		return findGuichetsByGuiCodeNouvEtablissement(guiCodeNouvEtablissement, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiCodeNouvEtablissement
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiCodeNouvEtablissement(String guiCodeNouvEtablissement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiCodeNouvEtablissement", startResult, maxRows, guiCodeNouvEtablissement);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDisparition
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDisparition(java.util.Calendar guiDisparition) throws DataAccessException {

		return findGuichetsByGuiDisparition(guiDisparition, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDisparition
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDisparition(java.util.Calendar guiDisparition, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDisparition", startResult, maxRows, guiDisparition);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiAdressePrelevement
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiAdressePrelevement(Integer guiAdressePrelevement) throws DataAccessException {

		return findGuichetsByGuiAdressePrelevement(guiAdressePrelevement, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiAdressePrelevement
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiAdressePrelevement(Integer guiAdressePrelevement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiAdressePrelevement", startResult, maxRows, guiAdressePrelevement);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiNatureGuichet
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiNatureGuichet(String guiNatureGuichet) throws DataAccessException {

		return findGuichetsByGuiNatureGuichet(guiNatureGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiNatureGuichet
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiNatureGuichet(String guiNatureGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiNatureGuichet", startResult, maxRows, guiNatureGuichet);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByPrimaryKey
	 *
	 */
	@Transactional
	public Guichets findGuichetsByPrimaryKey(Integer guiEtablissement, Integer guiGuichet, String guiPays) throws DataAccessException {

		return findGuichetsByPrimaryKey(guiEtablissement, guiGuichet, guiPays, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByPrimaryKey
	 *
	 */

	@Transactional
	public Guichets findGuichetsByPrimaryKey(Integer guiEtablissement, Integer guiGuichet, String guiPays, int startResult, int maxRows) throws DataAccessException {
		try {
			return executeQueryByNameSingleResult("findGuichetsByPrimaryKey", guiEtablissement, guiGuichet, guiPays);
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findGuichetsByGuiDebutValiditeBefore
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDebutValiditeBefore(java.util.Calendar guiDebutValidite) throws DataAccessException {

		return findGuichetsByGuiDebutValiditeBefore(guiDebutValidite, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDebutValiditeBefore
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDebutValiditeBefore(java.util.Calendar guiDebutValidite, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDebutValiditeBefore", startResult, maxRows, guiDebutValidite);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDebutValiditeAfter
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDebutValiditeAfter(java.util.Calendar guiDebutValidite) throws DataAccessException {

		return findGuichetsByGuiDebutValiditeAfter(guiDebutValidite, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDebutValiditeAfter
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDebutValiditeAfter(java.util.Calendar guiDebutValidite, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDebutValiditeAfter", startResult, maxRows, guiDebutValidite);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiContactPrelevement
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiContactPrelevement(Integer guiContactPrelevement) throws DataAccessException {

		return findGuichetsByGuiContactPrelevement(guiContactPrelevement, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiContactPrelevement
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiContactPrelevement(Integer guiContactPrelevement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiContactPrelevement", startResult, maxRows, guiContactPrelevement);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiPays
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiPays(String guiPays) throws DataAccessException {

		return findGuichetsByGuiPays(guiPays, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiPays
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiPays(String guiPays, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiPays", startResult, maxRows, guiPays);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiNouvGuichet
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiNouvGuichet(Integer guiNouvGuichet) throws DataAccessException {

		return findGuichetsByGuiNouvGuichet(guiNouvGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiNouvGuichet
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiNouvGuichet(Integer guiNouvGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiNouvGuichet", startResult, maxRows, guiNouvGuichet);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDisparitionAfter
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDisparitionAfter(java.util.Calendar guiDisparition) throws DataAccessException {

		return findGuichetsByGuiDisparitionAfter(guiDisparition, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDisparitionAfter
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDisparitionAfter(java.util.Calendar guiDisparition, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDisparitionAfter", startResult, maxRows, guiDisparition);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiChronoTrace
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiChronoTrace(Integer guiChronoTrace) throws DataAccessException {

		return findGuichetsByGuiChronoTrace(guiChronoTrace, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiChronoTrace
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiChronoTrace(Integer guiChronoTrace, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiChronoTrace", startResult, maxRows, guiChronoTrace);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findAllGuichetss
	 *
	 */
	@Transactional
	public Set<Guichets> findAllGuichetss() throws DataAccessException {

		return findAllGuichetss(-1, -1);
	}

	/**
	 * JPQL Query - findAllGuichetss
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findAllGuichetss(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllGuichetss", startResult, maxRows);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiNatureGuichetContaining
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiNatureGuichetContaining(String guiNatureGuichet) throws DataAccessException {

		return findGuichetsByGuiNatureGuichetContaining(guiNatureGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiNatureGuichetContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiNatureGuichetContaining(String guiNatureGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiNatureGuichetContaining", startResult, maxRows, guiNatureGuichet);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiNomGuichet
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiNomGuichet(String guiNomGuichet) throws DataAccessException {

		return findGuichetsByGuiNomGuichet(guiNomGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiNomGuichet
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiNomGuichet(String guiNomGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiNomGuichet", startResult, maxRows, guiNomGuichet);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiTiers
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiTiers(Integer guiTiers) throws DataAccessException {

		return findGuichetsByGuiTiers(guiTiers, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiTiers
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiTiers(Integer guiTiers, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiTiers", startResult, maxRows, guiTiers);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiGuichet
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiGuichet(Integer guiGuichet) throws DataAccessException {

		return findGuichetsByGuiGuichet(guiGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiGuichet
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiGuichet(Integer guiGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiGuichet", startResult, maxRows, guiGuichet);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDisparitionBefore
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDisparitionBefore(java.util.Calendar guiDisparition) throws DataAccessException {

		return findGuichetsByGuiDisparitionBefore(guiDisparition, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDisparitionBefore
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDisparitionBefore(java.util.Calendar guiDisparition, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDisparitionBefore", startResult, maxRows, guiDisparition);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiCodeNouvEtablissementContaining
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiCodeNouvEtablissementContaining(String guiCodeNouvEtablissement) throws DataAccessException {

		return findGuichetsByGuiCodeNouvEtablissementContaining(guiCodeNouvEtablissement, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiCodeNouvEtablissementContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiCodeNouvEtablissementContaining(String guiCodeNouvEtablissement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiCodeNouvEtablissementContaining", startResult, maxRows, guiCodeNouvEtablissement);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDomiciliationContaining
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDomiciliationContaining(String guiDomiciliation) throws DataAccessException {

		return findGuichetsByGuiDomiciliationContaining(guiDomiciliation, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDomiciliationContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDomiciliationContaining(String guiDomiciliation, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDomiciliationContaining", startResult, maxRows, guiDomiciliation);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiEtablissement
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiEtablissement(Integer guiEtablissement) throws DataAccessException {

		return findGuichetsByGuiEtablissement(guiEtablissement, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiEtablissement
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiEtablissement(Integer guiEtablissement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiEtablissement", startResult, maxRows, guiEtablissement);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiFinValiditeBefore
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiFinValiditeBefore(java.util.Calendar guiFinValidite) throws DataAccessException {

		return findGuichetsByGuiFinValiditeBefore(guiFinValidite, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiFinValiditeBefore
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiFinValiditeBefore(java.util.Calendar guiFinValidite, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiFinValiditeBefore", startResult, maxRows, guiFinValidite);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiFinValidite
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiFinValidite(java.util.Calendar guiFinValidite) throws DataAccessException {

		return findGuichetsByGuiFinValidite(guiFinValidite, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiFinValidite
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiFinValidite(java.util.Calendar guiFinValidite, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiFinValidite", startResult, maxRows, guiFinValidite);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiLocaliteCompensation1
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiLocaliteCompensation1(Integer guiLocaliteCompensation1) throws DataAccessException {

		return findGuichetsByGuiLocaliteCompensation1(guiLocaliteCompensation1, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiLocaliteCompensation1
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiLocaliteCompensation1(Integer guiLocaliteCompensation1, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiLocaliteCompensation1", startResult, maxRows, guiLocaliteCompensation1);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiCodeSituation
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiCodeSituation(Boolean guiCodeSituation) throws DataAccessException {

		return findGuichetsByGuiCodeSituation(guiCodeSituation, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiCodeSituation
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiCodeSituation(Boolean guiCodeSituation, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiCodeSituation", startResult, maxRows, guiCodeSituation);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiLocaliteCompensation2
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiLocaliteCompensation2(Integer guiLocaliteCompensation2) throws DataAccessException {

		return findGuichetsByGuiLocaliteCompensation2(guiLocaliteCompensation2, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiLocaliteCompensation2
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiLocaliteCompensation2(Integer guiLocaliteCompensation2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiLocaliteCompensation2", startResult, maxRows, guiLocaliteCompensation2);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDomiciliation
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDomiciliation(String guiDomiciliation) throws DataAccessException {

		return findGuichetsByGuiDomiciliation(guiDomiciliation, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDomiciliation
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDomiciliation(String guiDomiciliation, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDomiciliation", startResult, maxRows, guiDomiciliation);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiNomGuichetContaining
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiNomGuichetContaining(String guiNomGuichet) throws DataAccessException {

		return findGuichetsByGuiNomGuichetContaining(guiNomGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiNomGuichetContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiNomGuichetContaining(String guiNomGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiNomGuichetContaining", startResult, maxRows, guiNomGuichet);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiFinValiditeAfter
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiFinValiditeAfter(java.util.Calendar guiFinValidite) throws DataAccessException {

		return findGuichetsByGuiFinValiditeAfter(guiFinValidite, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiFinValiditeAfter
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiFinValiditeAfter(java.util.Calendar guiFinValidite, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiFinValiditeAfter", startResult, maxRows, guiFinValidite);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * JPQL Query - findGuichetsByGuiDebutValidite
	 *
	 */
	@Transactional
	public Set<Guichets> findGuichetsByGuiDebutValidite(java.util.Calendar guiDebutValidite) throws DataAccessException {

		return findGuichetsByGuiDebutValidite(guiDebutValidite, -1, -1);
	}

	/**
	 * JPQL Query - findGuichetsByGuiDebutValidite
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Guichets> findGuichetsByGuiDebutValidite(java.util.Calendar guiDebutValidite, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findGuichetsByGuiDebutValidite", startResult, maxRows, guiDebutValidite);
		return new LinkedHashSet<Guichets>(query.getResultList());
	}

	/**
	 * Used to determine whether or not to merge the entity or persist the entity when calling Store
	 * @see store
	 * 
	 *
	 */
	public boolean canBeMerged(Guichets entity) {
		return true;
	}
}
